package com.ruoyi.common.exception;

import java.util.Collection;
import java.util.Objects;
import java.util.function.Function;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;

/**
 * AssertUtils class
 *
 * @author xx
 */
public class AssertUtils {

    /**
     * 断言不为NULL
     *
     * @param o 对象
     * @param errorCode 对象为NULL时，定义的异常编码
     */
    public static void assertNotNull(Object o, String errorCode) {
        if (Objects.isNull(o)) {
            throw new GenericException().setCode(errorCode);
        }
    }

    /**
     * 断言不为NULL
     *
     * @param o 对象
     * @param errorCode 对象为NULL时，定义的异常编码
     */
    public static void assertNotNull(Object o, String errorCode, String errorMsg) {
        if (Objects.isNull(o)) {
            throw new GenericException(errorCode, errorMsg);
        }
    }

    /**
     * 断言不为空
     *
     * @param str 字符串
     * @param errorCode 字符串为空时，定义的异常编码
     */
    public static void assertNotBlank(String str, String errorCode) {
        if (StringUtils.isBlank(str)) {
            throw new GenericException().setCode(errorCode);
        }
    }

    /**
     * 断言不为空
     *
     * @param str 字符串
     * @param errorCode 字符串为空时，定义的异常编码
     * @param errorMsg 错误描述
     */
    public static void assertNotBlank(String str, String errorCode, String errorMsg) {
        if (StringUtils.isBlank(str)) {
            throw new GenericException(errorCode, errorMsg);
        }
    }

    /**
     * 断言两个参数相等
     *
     * @param o1 对象1
     * @param o2 对象2
     * @param errorCode 两个对象不相等时，定义的异常编码
     */
    public static void assertEqual(Object o1, Object o2, String errorCode) {
        if (!Objects.equals(o1, o2)) {
            throw new GenericException().setCode(errorCode);
        }
    }

    /**
     * 断言两个参数相等
     *
     * @param o1 字符串1
     * @param o2 字符串2
     * @param errorCode 字符串不相等时，定义的异常编码
     */
    public static void assertEqual(String o1, String o2, String errorCode) {
        if (!StringUtils.equals(o1, o2)) {
            throw new GenericException().setCode(errorCode);
        }
    }

    /**
     * 断言参数为false
     *
     * @param b bool
     * @param errorCode bool不为false时，定义的异常编码
     */
    public static void assertFalse(boolean b, String errorCode) {
        if (b) {
            throw new GenericException().setCode(errorCode);
        }
    }

    /**
     * 断言参数为false
     *
     * @param b bool
     * @param errorCode bool不为false时，定义的异常编码
     * @param errorMsg 错误描述
     */
    public static void assertFalse(boolean b, String errorCode, String errorMsg) {
        if (b) {
            throw new GenericException(errorCode, errorMsg);
        }
    }

    /**
     * 断言参数为true
     *
     * @param b bool
     * @param errorCode bool不为true时，定义的异常编码
     */
    public static void assertTrue(boolean b, String errorCode) {
        if (!b) {
            throw new GenericException().setCode(errorCode);
        }
    }

    /**
     * 断言参数为true
     *
     * @param b bool
     * @param errorCode bool不为true时，定义的异常编码
     * @param errorMsg 错误描述
     */
    public static void assertTrue(boolean b, String errorCode, String errorMsg) {
        if (!b) {
            throw new GenericException(errorCode, errorMsg);
        }
    }

    /**
     * 断言集合不为空
     *
     * @param collection 集合
     * @param errorCode 集合为空时，定义的异常编码
     */
    public static <T extends Collection<?>> void assertNotEmpty(T collection, String errorCode) {
        if (CollectionUtils.isEmpty(collection)) {
            throw new GenericException().setCode(errorCode);
        }
    }

    /**
     * 断言集合为空，若不符合条件则执行consumer
     *
     * @param collection 集合
     * @param callback 回调
     * @param <T> 泛型
     */
    public static <T extends Collection<?>> void assertEmpty(T collection,
            Function<T, RuntimeException> callback) {
        if (CollectionUtils.isNotEmpty(collection) && Objects.nonNull(callback)) {
            throw callback.apply(collection);
        }
    }
}
